// ============================================
// TypeScript 模块示例
// ============================================

// 1. 导出声明
// 导出变量
export const PI = 3.14159;
export let version = "1.0.0";

// 导出函数
export function calculateArea(radius: number): number {
    return PI * radius * radius;
}

// 导出类
export class Calculator {
    add(a: number, b: number): number {
        return a + b;
    }
    
    multiply(a: number, b: number): number {
        return a * b;
    }
}

// 导出接口
export interface User {
    id: number;
    name: string;
    email: string;
}

// 导出类型别名
export type Status = "active" | "inactive" | "pending";

// 2. 默认导出
class MathUtils {
    static square(x: number): number {
        return x * x;
    }
    
    static cube(x: number): number {
        return x * x * x;
    }
}

export default MathUtils;

// 3. 重新导出
// 假设我们有其他模块的导出
// export { SomeClass } from './other-module';
// export * from './another-module';

// 4. 导入示例（在实际使用中）
/*
// 命名导入
import { PI, calculateArea, Calculator } from './modules';

// 默认导入
import MathUtils from './modules';

// 混合导入
import MathUtils, { PI, User } from './modules';

// 导入所有
import * as ModuleUtils from './modules';

// 重命名导入
import { calculateArea as calcArea } from './modules';

// 仅导入类型
import type { User, Status } from './modules';
*/

// 5. 命名空间 (Namespaces)
namespace Geometry {
    export interface Point {
        x: number;
        y: number;
    }
    
    export interface Line {
        start: Point;
        end: Point;
    }
    
    export function distance(p1: Point, p2: Point): number {
        const dx = p1.x - p2.x;
        const dy = p1.y - p2.y;
        return Math.sqrt(dx * dx + dy * dy);
    }
    
    export function lineLength(line: Line): number {
        return distance(line.start, line.end);
    }
    
    // 嵌套命名空间
    export namespace Shapes {
        export class Rectangle {
            constructor(
                public width: number,
                public height: number
            ) {}
            
            area(): number {
                return this.width * this.height;
            }
        }
        
        export class Circle {
            constructor(public radius: number) {}
            
            area(): number {
                return PI * this.radius * this.radius;
            }
        }
    }
}

// 使用命名空间
let point1: Geometry.Point = { x: 0, y: 0 };
let point2: Geometry.Point = { x: 3, y: 4 };
let dist = Geometry.distance(point1, point2);

let rect = new Geometry.Shapes.Rectangle(10, 5);
let circle = new Geometry.Shapes.Circle(3);

console.log(`Distance: ${dist}`);
console.log(`Rectangle area: ${rect.area()}`);
console.log(`Circle area: ${circle.area()}`);

// 6. 命名空间别名
import Shapes = Geometry.Shapes;
let anotherRect = new Shapes.Rectangle(8, 6);

// 7. 模块解析
// TypeScript 支持多种模块解析策略
// 相对导入: import { something } from "./module"
// 非相对导入: import { something } from "module-name"

// 8. 声明合并 (Declaration Merging)
// 接口合并
interface Window {
    customProperty: string;
}

interface Window {
    anotherProperty: number;
}

// 现在 Window 接口包含两个属性

// 命名空间合并
namespace Animals {
    export class Dog {
        breed: string = "Unknown";
    }
}

namespace Animals {
    export class Cat {
        breed: string = "Unknown";
    }
    
    export function makeSound(animal: Dog | Cat): string {
        return "Some sound";
    }
}

// 现在可以使用合并后的命名空间
let dog = new Animals.Dog();
let cat = new Animals.Cat();
Animals.makeSound(dog);

// 9. 全局模块声明
// 在 .d.ts 文件中声明全局模块
/*
declare global {
    interface Window {
        myGlobalFunction(): void;
    }
}

declare module "my-library" {
    export function doSomething(): void;
}
*/

// 10. 动态导入
// 在实际应用中使用动态导入
/*
async function loadModule() {
    const module = await import('./some-module');
    module.doSomething();
}

// 或者使用 import() 类型
type ModuleType = typeof import('./some-module');
*/

// 11. 模块增强 (Module Augmentation)
// 扩展现有模块
/*
declare module "express" {
    interface Request {
        user?: User;
    }
}
*/

// 12. 三斜线指令
// 用于声明文件之间的依赖关系
/// <reference path="./types.d.ts" />
/// <reference types="node" />

console.log("=== 模块示例完成 ===");